#include<iostream>
#include<array>
#include<vector>
#include<string>
#include<bitset>
#include<cstring>
using namespace std;

#if 0
// int main()
// {
//     int a1[10];
//     array<int, 10> a2;
//     vector<int> a3(10);
//     printf("%p\n", &a1[0]);
//     printf("%p\n", &a2[0]);
//     printf("%p\n", &a3[0]);

//     return 0;
// }

template<class T, int N>
class Array
{
    T _a[N];
public:
    T& operator[] (int pos)
    {
        return _a[pos];
    }
};
int main()
{
    Array<int, 10> a;
    for(int i = 0; i < 10; i++) a[i] = i;
    for(int i = 0; i < 10; i++) cout << a[i] << ' ';

    cout << endl;

    Array<int, 20> a1;
    for(int i = 0; i < 20; i++) a1[i] = i * 10;
    for(int i = 0; i < 20; i++) cout << a1[i] << ' ';
    
    return 0;
}

/**************** 哨兵 ****************/
// template<class T>
// struct tree_node
// {
//     T _val;
//     tree_node* _left;
//     tree_node* _right;

//     static tree_node tree_node_null;

//     tree_node()
//         :_val(T())
//         ,_left(nullptr)
//         ,_right(nullptr)
//     {}

//     tree_node(const T& val, tree_node* le = &tree_node_null, tree_node* ri = &tree_node_null)
//         :_val(val)
//         ,_left(le)
//         ,_right(ri)
//     {}
// };

// tree_node<T>::tree_node_null = tree_node();

// template<class T, tree_node<T> null>
// class bs_tree
// {
//     typedef tree_node<T> node;
//     node* _root;
// public:
//     bs_tree()
//         :_root = 
//     {}
// }


// struct tree_node
// {
//     int _val;
//     tree_node* _left;
//     tree_node* _right;

//     tree_node()
//         :_val(int())
//         ,_left(nullptr)
//         ,_right(nullptr)
//     {}

//     // 建立哨兵节点
//     static tree_node null; // static修饰的成员变量不在对象中，在静态区，属于这个类、所有对象
//     tree_node(const int& val, tree_node* le = &null, tree_node* ri = &null)
//         :_val(val)
//         ,_left(le)
//         ,_right(ri)
//     {}
// };

// tree_node tree_node::null; // 这里会调用默认构造

// int main()
// {
//     tree_node t(999);
//     return 0;
// }

template<class T>
struct tree_node
{
    T _val;
    tree_node* _left;
    tree_node* _right;

    // 建立哨兵节点
    static tree_node null; // static修饰的成员变量不在对象中，在静态区，属于这个类、所有对象
    tree_node(const T& val, tree_node* le = &null, tree_node* ri = &null)
        :_val(val)
        ,_left(le)
        ,_right(ri)
    {}
};

template<class T>
tree_node<T> tree_node<T>::null = tree_node<T>(T(), nullptr, nullptr);

int main()
{
    // tree_node t(999); // 这里竟然不用显式实例化！哦C++23支持
    tree_node<int> t(999);
    tree_node<double> t1(3.14);
    return 0;
}

#endif

// template<class T>
// void Swap(T& a, T& b)
// {
//     cout << typeid(T).name() << endl; // 打印T的类型，不同平台对类型的表示可能不同。例如g++用i表示int，d表示double
//     T tmp = a;
//     a = b;
//     b = tmp;
// }

// int main()
// {
//     int i1 = 10, i2 = 20;
//     Swap(i1, i2);
// 	cout << i1 << ' ' << i2 << endl << endl;

//     double d1 = 1.23, d2 = 2.22;
//     Swap(d1, d2);
// 	cout << d1 << ' ' << d2 << endl;
//     return 0;
// }

// template<int N>
// void func()
// {
// 	cout << N << endl;
// 	// 注意：N不可修改
// }

// int main()
// {
// 	// func(); // err必须实例化
// 	func<10>();
// 	func<200>();

//     // 下面的写法是错误的，尖括号里面的必须是常量
//     // int a = 99;
//     // func<a>();   // err。可以将a用const修饰，即: const int a = 99;
//     return 0;
// }


// template<int N = 10>
// void func() 
// {
//     cout << N << endl;
// }

// int main() 
// {
//     func();
//     func<20>();
//     return 0;
// }

// void test01()
// {
//     array<int, 10> a;
//     cout << a.size() << endl;
// }

// void test02()
// {
//     bitset<20> b;
    
// }
// int main()
// {
//     test02();
//     return 0;
// }

// template<class T>
// void Print(const T& v)
// {
//     typename T::const_iterator it = v.begin();
//     while(it != v.end())
//     {
//         cout << *it << ' ';
//         ++it;
//     }
//     cout << endl;
// }

// int main()
// {
//     vector<int> v1 = { 1,2,3,4 };
//     vector<double> v2 = { 1.1,2.2,3.1,4.2 };
//     Print(v1);
//     Print(v2);
//     return 0;
// }

// template<class T>
// bool Less(const T& a, const T& b)
// {
// 	return a < b;
// }

// bool Less(const char* a, const char* b)
// {
// 	return strcmp(a, b) < 0;
// }

// int main()
// {
// 	cout << Less(1, 2) << endl;
// 	const char* s1 = "ddd";
// 	const char* s2 = "abd";
// 	cout << Less(s1, s2) << endl;
// 	return 0;
// }

// template<class T>
// void func(T t)
// {
//     cout << "void func(T t)" << endl;
// }

// template<>
// void func<int>(int t)
// {
//     cout << "void func(int t)" << endl;
// }

// int main()
// {
//     func('a');
//     func(3.1);
//     func(1);
//     return 0;
// }

// template<class T1, class T2>
// class Test
// {
//     T1 _v1;
//     T2 _v2;
// public:
//     Test() { cout << "class Test" << endl; }
// };

// // 全特化：T1为int、T2为char时，走下面
// template<>
// class Test<int, char>
// {
//     // ... 这里可以重定义成员变量
// public:
//     Test() { cout << "class Test<int, char> -->全特化" << endl; }
// };

// // 半特化：T2为int时，走下面
// template<class T1>
// class Test<T1, int>
// {
//     // ...
// public:
//     Test() { cout << "class Test<T1, int> -->半特化" << endl; }
// };

// // 半特化：T1、T2都为指针时，走下面
// template<class T1, class T2>
// class Test<T1*, T2*>
// {
//     // ...
// public:
//     Test() { cout << "class Test<T1*, T2*> -->半特化" << endl; }
// };

// // 半特化：T1、T2都为引用时，走下面
// template<class T1, class T2>
// class Test<T1&, T2&>
// {
//     // ...
// public:
//     Test() { cout << "class Test<T1&, T2&> -->半特化" << endl; }
// };

// // 半特化：T1为vector类型时，走下面
// template<class T1, class T2>
// class Test<vector<T1> , T2>
// {
//     // ...
// public:
//     Test() { cout << "class Test<vector<T1>, T2> -->半特化" << endl; }
// };

// int main()
// {
//     Test<int*, char*> t1;
//     Test<int&, int&> t2;
//     Test<vector<double>, double> t3;
//     return 0;
// }


template<class T>
class Test
{
    // ... 
public:
    void func(); // 函数声明
};

// 函数定义，需在函数名前指定类域
template<class T>
void Test<T>::func()
{
    cout << "void Test<T>::func()" << endl;
}

int main()
{
    Test<int> t;
    t.func();
    return 0;
}